// @ts-ignore
/* eslint-disable */
import { request } from '@umijs/max';

/** index GET /api/wx/pay/v3 */
export async function indexUsingGet(options?: { [key: string]: any }) {
  return request<string>('/api/wx/pay/v3', {
    method: 'GET',
    ...(options || {}),
  });
}

/** index PUT /api/wx/pay/v3 */
export async function indexUsingPut(options?: { [key: string]: any }) {
  return request<string>('/api/wx/pay/v3', {
    method: 'PUT',
    ...(options || {}),
  });
}

/** index POST /api/wx/pay/v3 */
export async function indexUsingPost(options?: { [key: string]: any }) {
  return request<string>('/api/wx/pay/v3', {
    method: 'POST',
    ...(options || {}),
  });
}

/** index DELETE /api/wx/pay/v3 */
export async function indexUsingDelete(options?: { [key: string]: any }) {
  return request<string>('/api/wx/pay/v3', {
    method: 'DELETE',
    ...(options || {}),
  });
}

/** index PATCH /api/wx/pay/v3 */
export async function indexUsingPatch(options?: { [key: string]: any }) {
  return request<string>('/api/wx/pay/v3', {
    method: 'PATCH',
    ...(options || {}),
  });
}

/** appPay GET /api/wx/pay/v3/appPay */
export async function appPayUsingGet(options?: { [key: string]: any }) {
  return request<string>('/api/wx/pay/v3/appPay', {
    method: 'GET',
    ...(options || {}),
  });
}

/** appPay PUT /api/wx/pay/v3/appPay */
export async function appPayUsingPut(options?: { [key: string]: any }) {
  return request<string>('/api/wx/pay/v3/appPay', {
    method: 'PUT',
    ...(options || {}),
  });
}

/** appPay POST /api/wx/pay/v3/appPay */
export async function appPayUsingPost(options?: { [key: string]: any }) {
  return request<string>('/api/wx/pay/v3/appPay', {
    method: 'POST',
    ...(options || {}),
  });
}

/** appPay DELETE /api/wx/pay/v3/appPay */
export async function appPayUsingDelete(options?: { [key: string]: any }) {
  return request<string>('/api/wx/pay/v3/appPay', {
    method: 'DELETE',
    ...(options || {}),
  });
}

/** appPay PATCH /api/wx/pay/v3/appPay */
export async function appPayUsingPatch(options?: { [key: string]: any }) {
  return request<string>('/api/wx/pay/v3/appPay', {
    method: 'PATCH',
    ...(options || {}),
  });
}

/** batchTransfer GET /api/wx/pay/v3/batchTransfer */
export async function batchTransferUsingGet(
  // 叠加生成的Param类型 (非body参数swagger默认没有生成对象)
  params: API.batchTransferUsingGETParams,
  options?: { [key: string]: any },
) {
  return request<string>('/api/wx/pay/v3/batchTransfer', {
    method: 'GET',
    params: {
      // openId has a default value: o-_-itxuXeGW3O1cxJ7FXNmq8Wf8
      openId: 'o-_-itxuXeGW3O1cxJ7FXNmq8Wf8',
      ...params,
    },
    ...(options || {}),
  });
}

/** batchTransfer PUT /api/wx/pay/v3/batchTransfer */
export async function batchTransferUsingPut(
  // 叠加生成的Param类型 (非body参数swagger默认没有生成对象)
  params: API.batchTransferUsingPUTParams,
  options?: { [key: string]: any },
) {
  return request<string>('/api/wx/pay/v3/batchTransfer', {
    method: 'PUT',
    params: {
      // openId has a default value: o-_-itxuXeGW3O1cxJ7FXNmq8Wf8
      openId: 'o-_-itxuXeGW3O1cxJ7FXNmq8Wf8',
      ...params,
    },
    ...(options || {}),
  });
}

/** batchTransfer POST /api/wx/pay/v3/batchTransfer */
export async function batchTransferUsingPost(
  // 叠加生成的Param类型 (非body参数swagger默认没有生成对象)
  params: API.batchTransferUsingPOSTParams,
  options?: { [key: string]: any },
) {
  return request<string>('/api/wx/pay/v3/batchTransfer', {
    method: 'POST',
    params: {
      // openId has a default value: o-_-itxuXeGW3O1cxJ7FXNmq8Wf8
      openId: 'o-_-itxuXeGW3O1cxJ7FXNmq8Wf8',
      ...params,
    },
    ...(options || {}),
  });
}

/** batchTransfer DELETE /api/wx/pay/v3/batchTransfer */
export async function batchTransferUsingDelete(
  // 叠加生成的Param类型 (非body参数swagger默认没有生成对象)
  params: API.batchTransferUsingDELETEParams,
  options?: { [key: string]: any },
) {
  return request<string>('/api/wx/pay/v3/batchTransfer', {
    method: 'DELETE',
    params: {
      // openId has a default value: o-_-itxuXeGW3O1cxJ7FXNmq8Wf8
      openId: 'o-_-itxuXeGW3O1cxJ7FXNmq8Wf8',
      ...params,
    },
    ...(options || {}),
  });
}

/** batchTransfer PATCH /api/wx/pay/v3/batchTransfer */
export async function batchTransferUsingPatch(
  // 叠加生成的Param类型 (非body参数swagger默认没有生成对象)
  params: API.batchTransferUsingPATCHParams,
  options?: { [key: string]: any },
) {
  return request<string>('/api/wx/pay/v3/batchTransfer', {
    method: 'PATCH',
    params: {
      // openId has a default value: o-_-itxuXeGW3O1cxJ7FXNmq8Wf8
      openId: 'o-_-itxuXeGW3O1cxJ7FXNmq8Wf8',
      ...params,
    },
    ...(options || {}),
  });
}

/** billDownload GET /api/wx/pay/v3/billDownload */
export async function billDownloadUsingGet(
  // 叠加生成的Param类型 (非body参数swagger默认没有生成对象)
  params: API.billDownloadUsingGETParams,
  options?: { [key: string]: any },
) {
  return request<string>('/api/wx/pay/v3/billDownload', {
    method: 'GET',
    params: {
      ...params,
    },
    ...(options || {}),
  });
}

/** billDownload PUT /api/wx/pay/v3/billDownload */
export async function billDownloadUsingPut(
  // 叠加生成的Param类型 (非body参数swagger默认没有生成对象)
  params: API.billDownloadUsingPUTParams,
  options?: { [key: string]: any },
) {
  return request<string>('/api/wx/pay/v3/billDownload', {
    method: 'PUT',
    params: {
      ...params,
    },
    ...(options || {}),
  });
}

/** billDownload POST /api/wx/pay/v3/billDownload */
export async function billDownloadUsingPost(
  // 叠加生成的Param类型 (非body参数swagger默认没有生成对象)
  params: API.billDownloadUsingPOSTParams,
  options?: { [key: string]: any },
) {
  return request<string>('/api/wx/pay/v3/billDownload', {
    method: 'POST',
    params: {
      ...params,
    },
    ...(options || {}),
  });
}

/** billDownload DELETE /api/wx/pay/v3/billDownload */
export async function billDownloadUsingDelete(
  // 叠加生成的Param类型 (非body参数swagger默认没有生成对象)
  params: API.billDownloadUsingDELETEParams,
  options?: { [key: string]: any },
) {
  return request<string>('/api/wx/pay/v3/billDownload', {
    method: 'DELETE',
    params: {
      ...params,
    },
    ...(options || {}),
  });
}

/** billDownload PATCH /api/wx/pay/v3/billDownload */
export async function billDownloadUsingPatch(
  // 叠加生成的Param类型 (非body参数swagger默认没有生成对象)
  params: API.billDownloadUsingPATCHParams,
  options?: { [key: string]: any },
) {
  return request<string>('/api/wx/pay/v3/billDownload', {
    method: 'PATCH',
    params: {
      ...params,
    },
    ...(options || {}),
  });
}

/** cipher GET /api/wx/pay/v3/cipher */
export async function cipherUsingGet(
  // 叠加生成的Param类型 (非body参数swagger默认没有生成对象)
  params: API.cipherUsingGETParams,
  options?: { [key: string]: any },
) {
  return request<string>('/api/wx/pay/v3/cipher', {
    method: 'GET',
    params: {
      ...params,
    },
    ...(options || {}),
  });
}

/** cipher PUT /api/wx/pay/v3/cipher */
export async function cipherUsingPut(
  // 叠加生成的Param类型 (非body参数swagger默认没有生成对象)
  params: API.cipherUsingPUTParams,
  options?: { [key: string]: any },
) {
  return request<string>('/api/wx/pay/v3/cipher', {
    method: 'PUT',
    params: {
      ...params,
    },
    ...(options || {}),
  });
}

/** cipher POST /api/wx/pay/v3/cipher */
export async function cipherUsingPost(
  // 叠加生成的Param类型 (非body参数swagger默认没有生成对象)
  params: API.cipherUsingPOSTParams,
  options?: { [key: string]: any },
) {
  return request<string>('/api/wx/pay/v3/cipher', {
    method: 'POST',
    params: {
      ...params,
    },
    ...(options || {}),
  });
}

/** cipher DELETE /api/wx/pay/v3/cipher */
export async function cipherUsingDelete(
  // 叠加生成的Param类型 (非body参数swagger默认没有生成对象)
  params: API.cipherUsingDELETEParams,
  options?: { [key: string]: any },
) {
  return request<string>('/api/wx/pay/v3/cipher', {
    method: 'DELETE',
    params: {
      ...params,
    },
    ...(options || {}),
  });
}

/** cipher PATCH /api/wx/pay/v3/cipher */
export async function cipherUsingPatch(
  // 叠加生成的Param类型 (非body参数swagger默认没有生成对象)
  params: API.cipherUsingPATCHParams,
  options?: { [key: string]: any },
) {
  return request<string>('/api/wx/pay/v3/cipher', {
    method: 'PATCH',
    params: {
      ...params,
    },
    ...(options || {}),
  });
}

/** v3Delete GET /api/wx/pay/v3/delete */
export async function v3DeleteUsingGet(options?: { [key: string]: any }) {
  return request<string>('/api/wx/pay/v3/delete', {
    method: 'GET',
    ...(options || {}),
  });
}

/** v3Delete PUT /api/wx/pay/v3/delete */
export async function v3DeleteUsingPut(options?: { [key: string]: any }) {
  return request<string>('/api/wx/pay/v3/delete', {
    method: 'PUT',
    ...(options || {}),
  });
}

/** v3Delete POST /api/wx/pay/v3/delete */
export async function v3DeleteUsingPost(options?: { [key: string]: any }) {
  return request<string>('/api/wx/pay/v3/delete', {
    method: 'POST',
    ...(options || {}),
  });
}

/** v3Delete DELETE /api/wx/pay/v3/delete */
export async function v3DeleteUsingDelete(options?: { [key: string]: any }) {
  return request<string>('/api/wx/pay/v3/delete', {
    method: 'DELETE',
    ...(options || {}),
  });
}

/** v3Delete PATCH /api/wx/pay/v3/delete */
export async function v3DeleteUsingPatch(options?: { [key: string]: any }) {
  return request<string>('/api/wx/pay/v3/delete', {
    method: 'PATCH',
    ...(options || {}),
  });
}

/** fundFlowBill GET /api/wx/pay/v3/fundFlowBill */
export async function fundFlowBillUsingGet(
  // 叠加生成的Param类型 (非body参数swagger默认没有生成对象)
  params: API.fundFlowBillUsingGETParams,
  options?: { [key: string]: any },
) {
  return request<string>('/api/wx/pay/v3/fundFlowBill', {
    method: 'GET',
    params: {
      ...params,
    },
    ...(options || {}),
  });
}

/** fundFlowBill PUT /api/wx/pay/v3/fundFlowBill */
export async function fundFlowBillUsingPut(
  // 叠加生成的Param类型 (非body参数swagger默认没有生成对象)
  params: API.fundFlowBillUsingPUTParams,
  options?: { [key: string]: any },
) {
  return request<string>('/api/wx/pay/v3/fundFlowBill', {
    method: 'PUT',
    params: {
      ...params,
    },
    ...(options || {}),
  });
}

/** fundFlowBill POST /api/wx/pay/v3/fundFlowBill */
export async function fundFlowBillUsingPost(
  // 叠加生成的Param类型 (非body参数swagger默认没有生成对象)
  params: API.fundFlowBillUsingPOSTParams,
  options?: { [key: string]: any },
) {
  return request<string>('/api/wx/pay/v3/fundFlowBill', {
    method: 'POST',
    params: {
      ...params,
    },
    ...(options || {}),
  });
}

/** fundFlowBill DELETE /api/wx/pay/v3/fundFlowBill */
export async function fundFlowBillUsingDelete(
  // 叠加生成的Param类型 (非body参数swagger默认没有生成对象)
  params: API.fundFlowBillUsingDELETEParams,
  options?: { [key: string]: any },
) {
  return request<string>('/api/wx/pay/v3/fundFlowBill', {
    method: 'DELETE',
    params: {
      ...params,
    },
    ...(options || {}),
  });
}

/** fundFlowBill PATCH /api/wx/pay/v3/fundFlowBill */
export async function fundFlowBillUsingPatch(
  // 叠加生成的Param类型 (非body参数swagger默认没有生成对象)
  params: API.fundFlowBillUsingPATCHParams,
  options?: { [key: string]: any },
) {
  return request<string>('/api/wx/pay/v3/fundFlowBill', {
    method: 'PATCH',
    params: {
      ...params,
    },
    ...(options || {}),
  });
}

/** v3Get GET /api/wx/pay/v3/get */
export async function v3GetUsingGet(options?: { [key: string]: any }) {
  return request<string>('/api/wx/pay/v3/get', {
    method: 'GET',
    ...(options || {}),
  });
}

/** v3Get PUT /api/wx/pay/v3/get */
export async function v3GetUsingPut(options?: { [key: string]: any }) {
  return request<string>('/api/wx/pay/v3/get', {
    method: 'PUT',
    ...(options || {}),
  });
}

/** v3Get POST /api/wx/pay/v3/get */
export async function v3GetUsingPost(options?: { [key: string]: any }) {
  return request<string>('/api/wx/pay/v3/get', {
    method: 'POST',
    ...(options || {}),
  });
}

/** v3Get DELETE /api/wx/pay/v3/get */
export async function v3GetUsingDelete(options?: { [key: string]: any }) {
  return request<string>('/api/wx/pay/v3/get', {
    method: 'DELETE',
    ...(options || {}),
  });
}

/** v3Get PATCH /api/wx/pay/v3/get */
export async function v3GetUsingPatch(options?: { [key: string]: any }) {
  return request<string>('/api/wx/pay/v3/get', {
    method: 'PATCH',
    ...(options || {}),
  });
}

/** payScoreServiceOrder GET /api/wx/pay/v3/getParams */
export async function payScoreServiceOrderUsingGet(options?: { [key: string]: any }) {
  return request<string>('/api/wx/pay/v3/getParams', {
    method: 'GET',
    ...(options || {}),
  });
}

/** payScoreServiceOrder PUT /api/wx/pay/v3/getParams */
export async function payScoreServiceOrderUsingPut(options?: { [key: string]: any }) {
  return request<string>('/api/wx/pay/v3/getParams', {
    method: 'PUT',
    ...(options || {}),
  });
}

/** payScoreServiceOrder POST /api/wx/pay/v3/getParams */
export async function payScoreServiceOrderUsingPost(options?: { [key: string]: any }) {
  return request<string>('/api/wx/pay/v3/getParams', {
    method: 'POST',
    ...(options || {}),
  });
}

/** payScoreServiceOrder DELETE /api/wx/pay/v3/getParams */
export async function payScoreServiceOrderUsingDelete(options?: { [key: string]: any }) {
  return request<string>('/api/wx/pay/v3/getParams', {
    method: 'DELETE',
    ...(options || {}),
  });
}

/** payScoreServiceOrder PATCH /api/wx/pay/v3/getParams */
export async function payScoreServiceOrderUsingPatch(options?: { [key: string]: any }) {
  return request<string>('/api/wx/pay/v3/getParams', {
    method: 'PATCH',
    ...(options || {}),
  });
}

/** platSerialNumber GET /api/wx/pay/v3/getPlatSerialNumber */
export async function platSerialNumberUsingGet(options?: { [key: string]: any }) {
  return request<string>('/api/wx/pay/v3/getPlatSerialNumber', {
    method: 'GET',
    ...(options || {}),
  });
}

/** platSerialNumber PUT /api/wx/pay/v3/getPlatSerialNumber */
export async function platSerialNumberUsingPut(options?: { [key: string]: any }) {
  return request<string>('/api/wx/pay/v3/getPlatSerialNumber', {
    method: 'PUT',
    ...(options || {}),
  });
}

/** platSerialNumber POST /api/wx/pay/v3/getPlatSerialNumber */
export async function platSerialNumberUsingPost(options?: { [key: string]: any }) {
  return request<string>('/api/wx/pay/v3/getPlatSerialNumber', {
    method: 'POST',
    ...(options || {}),
  });
}

/** platSerialNumber DELETE /api/wx/pay/v3/getPlatSerialNumber */
export async function platSerialNumberUsingDelete(options?: { [key: string]: any }) {
  return request<string>('/api/wx/pay/v3/getPlatSerialNumber', {
    method: 'DELETE',
    ...(options || {}),
  });
}

/** platSerialNumber PATCH /api/wx/pay/v3/getPlatSerialNumber */
export async function platSerialNumberUsingPatch(options?: { [key: string]: any }) {
  return request<string>('/api/wx/pay/v3/getPlatSerialNumber', {
    method: 'PATCH',
    ...(options || {}),
  });
}

/** serialNumber GET /api/wx/pay/v3/getSerialNumber */
export async function serialNumberUsingGet(options?: { [key: string]: any }) {
  return request<string>('/api/wx/pay/v3/getSerialNumber', {
    method: 'GET',
    ...(options || {}),
  });
}

/** serialNumber PUT /api/wx/pay/v3/getSerialNumber */
export async function serialNumberUsingPut(options?: { [key: string]: any }) {
  return request<string>('/api/wx/pay/v3/getSerialNumber', {
    method: 'PUT',
    ...(options || {}),
  });
}

/** serialNumber POST /api/wx/pay/v3/getSerialNumber */
export async function serialNumberUsingPost(options?: { [key: string]: any }) {
  return request<string>('/api/wx/pay/v3/getSerialNumber', {
    method: 'POST',
    ...(options || {}),
  });
}

/** serialNumber DELETE /api/wx/pay/v3/getSerialNumber */
export async function serialNumberUsingDelete(options?: { [key: string]: any }) {
  return request<string>('/api/wx/pay/v3/getSerialNumber', {
    method: 'DELETE',
    ...(options || {}),
  });
}

/** serialNumber PATCH /api/wx/pay/v3/getSerialNumber */
export async function serialNumberUsingPatch(options?: { [key: string]: any }) {
  return request<string>('/api/wx/pay/v3/getSerialNumber', {
    method: 'PATCH',
    ...(options || {}),
  });
}

/** jsApiPay GET /api/wx/pay/v3/jsApiPay */
export async function jsApiPayUsingGet(
  // 叠加生成的Param类型 (非body参数swagger默认没有生成对象)
  params: API.jsApiPayUsingGETParams,
  options?: { [key: string]: any },
) {
  return request<string>('/api/wx/pay/v3/jsApiPay', {
    method: 'GET',
    params: {
      // openId has a default value: o-_-itxuXeGW3O1cxJ7FXNmq8Wf8
      openId: 'o-_-itxuXeGW3O1cxJ7FXNmq8Wf8',
      ...params,
    },
    ...(options || {}),
  });
}

/** jsApiPay PUT /api/wx/pay/v3/jsApiPay */
export async function jsApiPayUsingPut(
  // 叠加生成的Param类型 (非body参数swagger默认没有生成对象)
  params: API.jsApiPayUsingPUTParams,
  options?: { [key: string]: any },
) {
  return request<string>('/api/wx/pay/v3/jsApiPay', {
    method: 'PUT',
    params: {
      // openId has a default value: o-_-itxuXeGW3O1cxJ7FXNmq8Wf8
      openId: 'o-_-itxuXeGW3O1cxJ7FXNmq8Wf8',
      ...params,
    },
    ...(options || {}),
  });
}

/** jsApiPay POST /api/wx/pay/v3/jsApiPay */
export async function jsApiPayUsingPost(
  // 叠加生成的Param类型 (非body参数swagger默认没有生成对象)
  params: API.jsApiPayUsingPOSTParams,
  options?: { [key: string]: any },
) {
  return request<string>('/api/wx/pay/v3/jsApiPay', {
    method: 'POST',
    params: {
      // openId has a default value: o-_-itxuXeGW3O1cxJ7FXNmq8Wf8
      openId: 'o-_-itxuXeGW3O1cxJ7FXNmq8Wf8',
      ...params,
    },
    ...(options || {}),
  });
}

/** jsApiPay DELETE /api/wx/pay/v3/jsApiPay */
export async function jsApiPayUsingDelete(
  // 叠加生成的Param类型 (非body参数swagger默认没有生成对象)
  params: API.jsApiPayUsingDELETEParams,
  options?: { [key: string]: any },
) {
  return request<string>('/api/wx/pay/v3/jsApiPay', {
    method: 'DELETE',
    params: {
      // openId has a default value: o-_-itxuXeGW3O1cxJ7FXNmq8Wf8
      openId: 'o-_-itxuXeGW3O1cxJ7FXNmq8Wf8',
      ...params,
    },
    ...(options || {}),
  });
}

/** jsApiPay PATCH /api/wx/pay/v3/jsApiPay */
export async function jsApiPayUsingPatch(
  // 叠加生成的Param类型 (非body参数swagger默认没有生成对象)
  params: API.jsApiPayUsingPATCHParams,
  options?: { [key: string]: any },
) {
  return request<string>('/api/wx/pay/v3/jsApiPay', {
    method: 'PATCH',
    params: {
      // openId has a default value: o-_-itxuXeGW3O1cxJ7FXNmq8Wf8
      openId: 'o-_-itxuXeGW3O1cxJ7FXNmq8Wf8',
      ...params,
    },
    ...(options || {}),
  });
}

/** nativePay GET /api/wx/pay/v3/nativePay */
export async function nativePayUsingGet(options?: { [key: string]: any }) {
  return request<string>('/api/wx/pay/v3/nativePay', {
    method: 'GET',
    ...(options || {}),
  });
}

/** nativePay PUT /api/wx/pay/v3/nativePay */
export async function nativePayUsingPut(options?: { [key: string]: any }) {
  return request<string>('/api/wx/pay/v3/nativePay', {
    method: 'PUT',
    ...(options || {}),
  });
}

/** nativePay POST /api/wx/pay/v3/nativePay */
export async function nativePayUsingPost(options?: { [key: string]: any }) {
  return request<string>('/api/wx/pay/v3/nativePay', {
    method: 'POST',
    ...(options || {}),
  });
}

/** nativePay DELETE /api/wx/pay/v3/nativePay */
export async function nativePayUsingDelete(options?: { [key: string]: any }) {
  return request<string>('/api/wx/pay/v3/nativePay', {
    method: 'DELETE',
    ...(options || {}),
  });
}

/** nativePay PATCH /api/wx/pay/v3/nativePay */
export async function nativePayUsingPatch(options?: { [key: string]: any }) {
  return request<string>('/api/wx/pay/v3/nativePay', {
    method: 'PATCH',
    ...(options || {}),
  });
}

/** payNotify GET /api/wx/pay/v3/payNotify */
export async function payNotifyUsingGet(options?: { [key: string]: any }) {
  return request<any>('/api/wx/pay/v3/payNotify', {
    method: 'GET',
    ...(options || {}),
  });
}

/** payNotify POST /api/wx/pay/v3/payNotify */
export async function payNotifyUsingPost(options?: { [key: string]: any }) {
  return request<any>('/api/wx/pay/v3/payNotify', {
    method: 'POST',
    ...(options || {}),
  });
}

/** platformCert GET /api/wx/pay/v3/platformCert */
export async function platformCertUsingGet(options?: { [key: string]: any }) {
  return request<string>('/api/wx/pay/v3/platformCert', {
    method: 'GET',
    ...(options || {}),
  });
}

/** platformCert PUT /api/wx/pay/v3/platformCert */
export async function platformCertUsingPut(options?: { [key: string]: any }) {
  return request<string>('/api/wx/pay/v3/platformCert', {
    method: 'PUT',
    ...(options || {}),
  });
}

/** platformCert POST /api/wx/pay/v3/platformCert */
export async function platformCertUsingPost(options?: { [key: string]: any }) {
  return request<string>('/api/wx/pay/v3/platformCert', {
    method: 'POST',
    ...(options || {}),
  });
}

/** platformCert DELETE /api/wx/pay/v3/platformCert */
export async function platformCertUsingDelete(options?: { [key: string]: any }) {
  return request<string>('/api/wx/pay/v3/platformCert', {
    method: 'DELETE',
    ...(options || {}),
  });
}

/** platformCert PATCH /api/wx/pay/v3/platformCert */
export async function platformCertUsingPatch(options?: { [key: string]: any }) {
  return request<string>('/api/wx/pay/v3/platformCert', {
    method: 'PATCH',
    ...(options || {}),
  });
}

/** payGiftActivity GET /api/wx/pay/v3/post */
export async function payGiftActivityUsingGet(options?: { [key: string]: any }) {
  return request<string>('/api/wx/pay/v3/post', {
    method: 'GET',
    ...(options || {}),
  });
}

/** payGiftActivity PUT /api/wx/pay/v3/post */
export async function payGiftActivityUsingPut(options?: { [key: string]: any }) {
  return request<string>('/api/wx/pay/v3/post', {
    method: 'PUT',
    ...(options || {}),
  });
}

/** payGiftActivity POST /api/wx/pay/v3/post */
export async function payGiftActivityUsingPost(options?: { [key: string]: any }) {
  return request<string>('/api/wx/pay/v3/post', {
    method: 'POST',
    ...(options || {}),
  });
}

/** payGiftActivity DELETE /api/wx/pay/v3/post */
export async function payGiftActivityUsingDelete(options?: { [key: string]: any }) {
  return request<string>('/api/wx/pay/v3/post', {
    method: 'DELETE',
    ...(options || {}),
  });
}

/** payGiftActivity PATCH /api/wx/pay/v3/post */
export async function payGiftActivityUsingPatch(options?: { [key: string]: any }) {
  return request<string>('/api/wx/pay/v3/post', {
    method: 'PATCH',
    ...(options || {}),
  });
}

/** put GET /api/wx/pay/v3/put */
export async function putUsingGet(options?: { [key: string]: any }) {
  return request<string>('/api/wx/pay/v3/put', {
    method: 'GET',
    ...(options || {}),
  });
}

/** put PUT /api/wx/pay/v3/put */
export async function putUsingPut(options?: { [key: string]: any }) {
  return request<string>('/api/wx/pay/v3/put', {
    method: 'PUT',
    ...(options || {}),
  });
}

/** put POST /api/wx/pay/v3/put */
export async function putUsingPost(options?: { [key: string]: any }) {
  return request<string>('/api/wx/pay/v3/put', {
    method: 'POST',
    ...(options || {}),
  });
}

/** put DELETE /api/wx/pay/v3/put */
export async function putUsingDelete(options?: { [key: string]: any }) {
  return request<string>('/api/wx/pay/v3/put', {
    method: 'DELETE',
    ...(options || {}),
  });
}

/** put PATCH /api/wx/pay/v3/put */
export async function putUsingPatch(options?: { [key: string]: any }) {
  return request<string>('/api/wx/pay/v3/put', {
    method: 'PATCH',
    ...(options || {}),
  });
}

/** query GET /api/wx/pay/v3/query */
export async function queryUsingGet(
  // 叠加生成的Param类型 (非body参数swagger默认没有生成对象)
  params: API.queryUsingGETParams,
  options?: { [key: string]: any },
) {
  return request<string>('/api/wx/pay/v3/query', {
    method: 'GET',
    params: {
      ...params,
    },
    ...(options || {}),
  });
}

/** query PUT /api/wx/pay/v3/query */
export async function queryUsingPut(
  // 叠加生成的Param类型 (非body参数swagger默认没有生成对象)
  params: API.queryUsingPUTParams,
  options?: { [key: string]: any },
) {
  return request<string>('/api/wx/pay/v3/query', {
    method: 'PUT',
    params: {
      ...params,
    },
    ...(options || {}),
  });
}

/** query POST /api/wx/pay/v3/query */
export async function queryUsingPost(
  // 叠加生成的Param类型 (非body参数swagger默认没有生成对象)
  params: API.queryUsingPOSTParams,
  options?: { [key: string]: any },
) {
  return request<string>('/api/wx/pay/v3/query', {
    method: 'POST',
    params: {
      ...params,
    },
    ...(options || {}),
  });
}

/** query DELETE /api/wx/pay/v3/query */
export async function queryUsingDelete(
  // 叠加生成的Param类型 (非body参数swagger默认没有生成对象)
  params: API.queryUsingDELETEParams,
  options?: { [key: string]: any },
) {
  return request<string>('/api/wx/pay/v3/query', {
    method: 'DELETE',
    params: {
      ...params,
    },
    ...(options || {}),
  });
}

/** query PATCH /api/wx/pay/v3/query */
export async function queryUsingPatch(
  // 叠加生成的Param类型 (非body参数swagger默认没有生成对象)
  params: API.queryUsingPATCHParams,
  options?: { [key: string]: any },
) {
  return request<string>('/api/wx/pay/v3/query', {
    method: 'PATCH',
    params: {
      ...params,
    },
    ...(options || {}),
  });
}

/** refund GET /api/wx/pay/v3/refund */
export async function refundUsingGet(
  // 叠加生成的Param类型 (非body参数swagger默认没有生成对象)
  params: API.refundUsingGETParams,
  options?: { [key: string]: any },
) {
  return request<string>('/api/wx/pay/v3/refund', {
    method: 'GET',
    params: {
      ...params,
    },
    ...(options || {}),
  });
}

/** refund PUT /api/wx/pay/v3/refund */
export async function refundUsingPut(
  // 叠加生成的Param类型 (非body参数swagger默认没有生成对象)
  params: API.refundUsingPUTParams,
  options?: { [key: string]: any },
) {
  return request<string>('/api/wx/pay/v3/refund', {
    method: 'PUT',
    params: {
      ...params,
    },
    ...(options || {}),
  });
}

/** refund POST /api/wx/pay/v3/refund */
export async function refundUsingPost(
  // 叠加生成的Param类型 (非body参数swagger默认没有生成对象)
  params: API.refundUsingPOSTParams,
  options?: { [key: string]: any },
) {
  return request<string>('/api/wx/pay/v3/refund', {
    method: 'POST',
    params: {
      ...params,
    },
    ...(options || {}),
  });
}

/** refund DELETE /api/wx/pay/v3/refund */
export async function refundUsingDelete(
  // 叠加生成的Param类型 (非body参数swagger默认没有生成对象)
  params: API.refundUsingDELETEParams,
  options?: { [key: string]: any },
) {
  return request<string>('/api/wx/pay/v3/refund', {
    method: 'DELETE',
    params: {
      ...params,
    },
    ...(options || {}),
  });
}

/** refund PATCH /api/wx/pay/v3/refund */
export async function refundUsingPatch(
  // 叠加生成的Param类型 (非body参数swagger默认没有生成对象)
  params: API.refundUsingPATCHParams,
  options?: { [key: string]: any },
) {
  return request<string>('/api/wx/pay/v3/refund', {
    method: 'PATCH',
    params: {
      ...params,
    },
    ...(options || {}),
  });
}

/** refundNotify GET /api/wx/pay/v3/refundNotify */
export async function refundNotifyUsingGet(options?: { [key: string]: any }) {
  return request<any>('/api/wx/pay/v3/refundNotify', {
    method: 'GET',
    ...(options || {}),
  });
}

/** refundNotify POST /api/wx/pay/v3/refundNotify */
export async function refundNotifyUsingPost(options?: { [key: string]: any }) {
  return request<any>('/api/wx/pay/v3/refundNotify', {
    method: 'POST',
    ...(options || {}),
  });
}

/** sensitive GET /api/wx/pay/v3/sensitive */
export async function sensitiveUsingGet(options?: { [key: string]: any }) {
  return request<string>('/api/wx/pay/v3/sensitive', {
    method: 'GET',
    ...(options || {}),
  });
}

/** sensitive PUT /api/wx/pay/v3/sensitive */
export async function sensitiveUsingPut(options?: { [key: string]: any }) {
  return request<string>('/api/wx/pay/v3/sensitive', {
    method: 'PUT',
    ...(options || {}),
  });
}

/** sensitive POST /api/wx/pay/v3/sensitive */
export async function sensitiveUsingPost(options?: { [key: string]: any }) {
  return request<string>('/api/wx/pay/v3/sensitive', {
    method: 'POST',
    ...(options || {}),
  });
}

/** sensitive DELETE /api/wx/pay/v3/sensitive */
export async function sensitiveUsingDelete(options?: { [key: string]: any }) {
  return request<string>('/api/wx/pay/v3/sensitive', {
    method: 'DELETE',
    ...(options || {}),
  });
}

/** sensitive PATCH /api/wx/pay/v3/sensitive */
export async function sensitiveUsingPatch(options?: { [key: string]: any }) {
  return request<string>('/api/wx/pay/v3/sensitive', {
    method: 'PATCH',
    ...(options || {}),
  });
}

/** smPlatformCert GET /api/wx/pay/v3/smPlatformCert */
export async function smPlatformCertUsingGet(options?: { [key: string]: any }) {
  return request<string>('/api/wx/pay/v3/smPlatformCert', {
    method: 'GET',
    ...(options || {}),
  });
}

/** smPlatformCert PUT /api/wx/pay/v3/smPlatformCert */
export async function smPlatformCertUsingPut(options?: { [key: string]: any }) {
  return request<string>('/api/wx/pay/v3/smPlatformCert', {
    method: 'PUT',
    ...(options || {}),
  });
}

/** smPlatformCert POST /api/wx/pay/v3/smPlatformCert */
export async function smPlatformCertUsingPost(options?: { [key: string]: any }) {
  return request<string>('/api/wx/pay/v3/smPlatformCert', {
    method: 'POST',
    ...(options || {}),
  });
}

/** smPlatformCert DELETE /api/wx/pay/v3/smPlatformCert */
export async function smPlatformCertUsingDelete(options?: { [key: string]: any }) {
  return request<string>('/api/wx/pay/v3/smPlatformCert', {
    method: 'DELETE',
    ...(options || {}),
  });
}

/** smPlatformCert PATCH /api/wx/pay/v3/smPlatformCert */
export async function smPlatformCertUsingPatch(options?: { [key: string]: any }) {
  return request<string>('/api/wx/pay/v3/smPlatformCert', {
    method: 'PATCH',
    ...(options || {}),
  });
}

/** tradeBill GET /api/wx/pay/v3/tradeBill */
export async function tradeBillUsingGet(
  // 叠加生成的Param类型 (非body参数swagger默认没有生成对象)
  params: API.tradeBillUsingGETParams,
  options?: { [key: string]: any },
) {
  return request<string>('/api/wx/pay/v3/tradeBill', {
    method: 'GET',
    params: {
      ...params,
    },
    ...(options || {}),
  });
}

/** tradeBill PUT /api/wx/pay/v3/tradeBill */
export async function tradeBillUsingPut(
  // 叠加生成的Param类型 (非body参数swagger默认没有生成对象)
  params: API.tradeBillUsingPUTParams,
  options?: { [key: string]: any },
) {
  return request<string>('/api/wx/pay/v3/tradeBill', {
    method: 'PUT',
    params: {
      ...params,
    },
    ...(options || {}),
  });
}

/** tradeBill POST /api/wx/pay/v3/tradeBill */
export async function tradeBillUsingPost(
  // 叠加生成的Param类型 (非body参数swagger默认没有生成对象)
  params: API.tradeBillUsingPOSTParams,
  options?: { [key: string]: any },
) {
  return request<string>('/api/wx/pay/v3/tradeBill', {
    method: 'POST',
    params: {
      ...params,
    },
    ...(options || {}),
  });
}

/** tradeBill DELETE /api/wx/pay/v3/tradeBill */
export async function tradeBillUsingDelete(
  // 叠加生成的Param类型 (非body参数swagger默认没有生成对象)
  params: API.tradeBillUsingDELETEParams,
  options?: { [key: string]: any },
) {
  return request<string>('/api/wx/pay/v3/tradeBill', {
    method: 'DELETE',
    params: {
      ...params,
    },
    ...(options || {}),
  });
}

/** tradeBill PATCH /api/wx/pay/v3/tradeBill */
export async function tradeBillUsingPatch(
  // 叠加生成的Param类型 (非body参数swagger默认没有生成对象)
  params: API.tradeBillUsingPATCHParams,
  options?: { [key: string]: any },
) {
  return request<string>('/api/wx/pay/v3/tradeBill', {
    method: 'PATCH',
    params: {
      ...params,
    },
    ...(options || {}),
  });
}

/** v3Upload GET /api/wx/pay/v3/upload */
export async function v3UploadUsingGet(options?: { [key: string]: any }) {
  return request<string>('/api/wx/pay/v3/upload', {
    method: 'GET',
    ...(options || {}),
  });
}

/** v3Upload PUT /api/wx/pay/v3/upload */
export async function v3UploadUsingPut(options?: { [key: string]: any }) {
  return request<string>('/api/wx/pay/v3/upload', {
    method: 'PUT',
    ...(options || {}),
  });
}

/** v3Upload POST /api/wx/pay/v3/upload */
export async function v3UploadUsingPost(options?: { [key: string]: any }) {
  return request<string>('/api/wx/pay/v3/upload', {
    method: 'POST',
    ...(options || {}),
  });
}

/** v3Upload DELETE /api/wx/pay/v3/upload */
export async function v3UploadUsingDelete(options?: { [key: string]: any }) {
  return request<string>('/api/wx/pay/v3/upload', {
    method: 'DELETE',
    ...(options || {}),
  });
}

/** v3Upload PATCH /api/wx/pay/v3/upload */
export async function v3UploadUsingPatch(options?: { [key: string]: any }) {
  return request<string>('/api/wx/pay/v3/upload', {
    method: 'PATCH',
    ...(options || {}),
  });
}

/** wapPay GET /api/wx/pay/v3/wapPay */
export async function wapPayUsingGet(options?: { [key: string]: any }) {
  return request<string>('/api/wx/pay/v3/wapPay', {
    method: 'GET',
    ...(options || {}),
  });
}

/** wapPay PUT /api/wx/pay/v3/wapPay */
export async function wapPayUsingPut(options?: { [key: string]: any }) {
  return request<string>('/api/wx/pay/v3/wapPay', {
    method: 'PUT',
    ...(options || {}),
  });
}

/** wapPay POST /api/wx/pay/v3/wapPay */
export async function wapPayUsingPost(options?: { [key: string]: any }) {
  return request<string>('/api/wx/pay/v3/wapPay', {
    method: 'POST',
    ...(options || {}),
  });
}

/** wapPay DELETE /api/wx/pay/v3/wapPay */
export async function wapPayUsingDelete(options?: { [key: string]: any }) {
  return request<string>('/api/wx/pay/v3/wapPay', {
    method: 'DELETE',
    ...(options || {}),
  });
}

/** wapPay PATCH /api/wx/pay/v3/wapPay */
export async function wapPayUsingPatch(options?: { [key: string]: any }) {
  return request<string>('/api/wx/pay/v3/wapPay', {
    method: 'PATCH',
    ...(options || {}),
  });
}
